#include "SoundManager.h"


SoundManager::SoundManager()
{
	m_pDevice = alcOpenDevice(NULL);
	
	if (!m_pDevice)
	{
		LOG("Error open AL Device!\n");
	}
	else
	{
		m_pContext = alcCreateContext(m_pDevice);
		alcMakeContextCurrent(m_pContext);
		alGetError();
	}
}


SoundManager::~SoundManager()
{
}



ALuint SoundManager::Load(char* file_name)
{
	ALuint buffer_id, source_id;
	ALsizei freq, size;
	ALenum format;
	unsigned char* data;

	// load wav file

	loadWavFile(file_name, data, &size, &freq, &format);


	// buffer the sound
	//create our openAL buffer and check for success
	alGenBuffers(1, &buffer_id);
	alGenSources(1, &source_id);
	//now we put our data into the openAL buffer and
	//check for success
	alBufferData(buffer_id, format, (void*)data,
		size, freq);
	delete[] data;

	// bind the source
	alSourcei(source_id, AL_BUFFER, buffer_id);
	return 1;
}
void SoundManager::Play(ALuint source, bool loop)
{

}
void SoundManager::Pause(ALuint source)
{
}
void SoundManager::Stop(ALuint source)
{
}
bool SoundManager::isPlaying(ALuint buffer_id)
{
	return 1;
}

bool loadWavFile(char* filename, unsigned char* data, ALsizei* size, ALsizei* frequency, ALenum* format)
{

	//Local Declarations
	FILE* soundFile = NULL;
	WAVE_Format wave_format;
	RIFF_Header riff_header;
	WAVE_Data wave_data;
	soundFile = fopen(filename, "rb");
	if (!soundFile)
		LOG("ERROR loading Sound!\n")

		// Read in the first chunk into the struct
		fread(&riff_header, sizeof(RIFF_Header), 1, soundFile);

	//check for RIFF and WAVE tag in memeory
	if ((riff_header.chunkID[0] != 'R' ||
		riff_header.chunkID[1] != 'I' ||
		riff_header.chunkID[2] != 'F' ||
		riff_header.chunkID[3] != 'F') ||
		(riff_header.format[0] != 'W' ||
		riff_header.format[1] != 'A' ||
		riff_header.format[2] != 'V' ||
		riff_header.format[3] != 'E'))
		LOG("Invalid RIFF or WAVE Header");

	//Read in the 2nd chunk for the wave info
	fread(&wave_format, sizeof(WAVE_Format), 1, soundFile);
	//check for fmt tag in memory
	if (wave_format.subChunkID[0] != 'f' ||
		wave_format.subChunkID[1] != 'm' ||
		wave_format.subChunkID[2] != 't' ||
		wave_format.subChunkID[3] != ' ')
		LOG("Invalid Wave Format");

	//check for extra parameters;
	if (wave_format.subChunkSize > 16)
		fseek(soundFile, sizeof(short), SEEK_CUR);

	//Read in the the last byte of data before the sound file
	fread(&wave_data, sizeof(WAVE_Data), 1, soundFile);
	//check for data tag in memory
	if (wave_data.subChunkID[0] != 'd' ||
		wave_data.subChunkID[1] != 'a' ||
		wave_data.subChunkID[2] != 't' ||
		wave_data.subChunkID[3] != 'a')
		throw ("Invalid data header");

	//Allocate memory for data
	data = new unsigned char[wave_data.subChunk2Size];

	// Read in the sound data into the soundData variable
	if (!fread(data, wave_data.subChunk2Size, 1, soundFile))
		throw ("error loading WAVE data into struct!");

	//Now we set the variables that we passed in with the
	//data from the structs
	*size = wave_data.subChunk2Size;
	*frequency = wave_format.sampleRate;
	//The format is worked out by looking at the number of
	//channels and the bits per sample.
	if (wave_format.numChannels == 1) {
		if (wave_format.bitsPerSample == 8)
			*format = AL_FORMAT_MONO8;
		else if (wave_format.bitsPerSample == 16)
			*format = AL_FORMAT_MONO16;
	}
	else if (wave_format.numChannels == 2) {
		if (wave_format.bitsPerSample == 8)
			*format = AL_FORMAT_STEREO8;
		else if (wave_format.bitsPerSample == 16)
			*format = AL_FORMAT_STEREO16;
	}
	fclose(soundFile);
	return true;
}